home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Bank smakow / BankSmakow.air / BankSmakow.swf / scripts / mx / effects / Effect.as < prev    next >
Text File  |  2009-12-16  |  23KB  |  740 lines
  1. package mx.effects
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.EventDispatcher;
  5.    import flash.utils.getQualifiedClassName;
  6.    import mx.core.IFlexDisplayObject;
  7.    import mx.core.mx_internal;
  8.    import mx.effects.effectClasses.AddRemoveEffectTargetFilter;
  9.    import mx.effects.effectClasses.HideShowEffectTargetFilter;
  10.    import mx.effects.effectClasses.PropertyChanges;
  11.    import mx.events.EffectEvent;
  12.    import mx.managers.LayoutManager;
  13.    
  14.    use namespace mx_internal;
  15.    
  16.    public class Effect extends EventDispatcher implements IEffect
  17.    {
  18.       
  19.       mx_internal static const VERSION:String = "3.5.0.12683";
  20.        
  21.       
  22.       private var _perElementOffset:Number = 0;
  23.       
  24.       private var _hideFocusRing:Boolean = false;
  25.       
  26.       private var _customFilter:EffectTargetFilter;
  27.       
  28.       public var repeatCount:int = 1;
  29.       
  30.       public var suspendBackgroundProcessing:Boolean = false;
  31.       
  32.       public var startDelay:int = 0;
  33.       
  34.       private var _relevantProperties:Array;
  35.       
  36.       private var _callValidateNow:Boolean = false;
  37.       
  38.       mx_internal var applyActualDimensions:Boolean = true;
  39.       
  40.       private var _filter:String;
  41.       
  42.       private var _triggerEvent:Event;
  43.       
  44.       private var _effectTargetHost:IEffectTargetHost;
  45.       
  46.       mx_internal var durationExplicitlySet:Boolean = false;
  47.       
  48.       public var repeatDelay:int = 0;
  49.       
  50.       private var _targets:Array;
  51.       
  52.       mx_internal var propertyChangesArray:Array;
  53.       
  54.       mx_internal var filterObject:EffectTargetFilter;
  55.       
  56.       protected var endValuesCaptured:Boolean = false;
  57.       
  58.       public var instanceClass:Class;
  59.       
  60.       private var _duration:Number = 500;
  61.       
  62.       private var isPaused:Boolean = false;
  63.       
  64.       private var _relevantStyles:Array;
  65.       
  66.       private var _instances:Array;
  67.       
  68.       public function Effect(param1:Object = null)
  69.       {
  70.          _instances = [];
  71.          instanceClass = IEffectInstance;
  72.          _relevantStyles = [];
  73.          _targets = [];
  74.          super();
  75.          this.target = param1;
  76.       }
  77.       
  78.       private static function mergeArrays(param1:Array, param2:Array) : Array
  79.       {
  80.          var _loc3_:int = 0;
  81.          var _loc4_:Boolean = false;
  82.          var _loc5_:int = 0;
  83.          if(param2)
  84.          {
  85.             _loc3_ = 0;
  86.             while(_loc3_ < param2.length)
  87.             {
  88.                _loc4_ = true;
  89.                _loc5_ = 0;
  90.                while(_loc5_ < param1.length)
  91.                {
  92.                   if(param1[_loc5_] == param2[_loc3_])
  93.                   {
  94.                      _loc4_ = false;
  95.                      break;
  96.                   }
  97.                   _loc5_++;
  98.                }
  99.                if(_loc4_)
  100.                {
  101.                   param1.push(param2[_loc3_]);
  102.                }
  103.                _loc3_++;
  104.             }
  105.          }
  106.          return param1;
  107.       }
  108.       
  109.       private static function stripUnchangedValues(param1:Array) : Array
  110.       {
  111.          var _loc3_:* = null;
  112.          var _loc2_:int = 0;
  113.          while(_loc2_ < param1.length)
  114.          {
  115.             for(_loc3_ in param1[_loc2_].start)
  116.             {
  117.                if(param1[_loc2_].start[_loc3_] == param1[_loc2_].end[_loc3_] || typeof param1[_loc2_].start[_loc3_] == "number" && typeof param1[_loc2_].end[_loc3_] == "number" && isNaN(param1[_loc2_].start[_loc3_]) && isNaN(param1[_loc2_].end[_loc3_]))
  118.                {
  119.                   delete param1[_loc2_].start[_loc3_];
  120.                   delete param1[_loc2_].end[_loc3_];
  121.                }
  122.             }
  123.             _loc2_++;
  124.          }
  125.          return param1;
  126.       }
  127.       
  128.       public function get targets() : Array
  129.       {
  130.          return _targets;
  131.       }
  132.       
  133.       public function set targets(param1:Array) : void
  134.       {
  135.          var _loc2_:int = param1.length;
  136.          var _loc3_:int = _loc2_ - 1;
  137.          while(_loc3_ > 0)
  138.          {
  139.             if(param1[_loc3_] == null)
  140.             {
  141.                param1.splice(_loc3_,1);
  142.             }
  143.             _loc3_--;
  144.          }
  145.          _targets = param1;
  146.       }
  147.       
  148.       public function set hideFocusRing(param1:Boolean) : void
  149.       {
  150.          _hideFocusRing = param1;
  151.       }
  152.       
  153.       public function get hideFocusRing() : Boolean
  154.       {
  155.          return _hideFocusRing;
  156.       }
  157.       
  158.       public function stop() : void
  159.       {
  160.          var _loc3_:IEffectInstance = null;
  161.          var _loc1_:int = _instances.length;
  162.          var _loc2_:int = _loc1_;
  163.          while(_loc2_ >= 0)
  164.          {
  165.             _loc3_ = IEffectInstance(_instances[_loc2_]);
  166.             if(_loc3_)
  167.             {
  168.                _loc3_.stop();
  169.             }
  170.             _loc2_--;
  171.          }
  172.       }
  173.       
  174.       public function captureStartValues() : void
  175.       {
  176.          if(targets.length > 0)
  177.          {
  178.             propertyChangesArray = captureValues(null,true);
  179.             _callValidateNow = true;
  180.          }
  181.          endValuesCaptured = false;
  182.       }
  183.       
  184.       mx_internal function captureValues(param1:Array, param2:Boolean) : Array
  185.       {
  186.          var _loc3_:int = 0;
  187.          var _loc4_:int = 0;
  188.          var _loc6_:Object = null;
  189.          var _loc7_:Object = null;
  190.          var _loc8_:int = 0;
  191.          var _loc9_:int = 0;
  192.          if(!param1)
  193.          {
  194.             param1 = [];
  195.             _loc3_ = targets.length;
  196.             _loc4_ = 0;
  197.             while(_loc4_ < _loc3_)
  198.             {
  199.                param1.push(new PropertyChanges(targets[_loc4_]));
  200.                _loc4_++;
  201.             }
  202.          }
  203.          var _loc5_:Array;
  204.          if((_loc5_ = !mx_internal::filterObject ? relevantProperties : mergeArrays(relevantProperties,mx_internal::filterObject.filterProperties)) && _loc5_.length > 0)
  205.          {
  206.             _loc3_ = param1.length;
  207.             _loc4_ = 0;
  208.             while(_loc4_ < _loc3_)
  209.             {
  210.                _loc7_ = param1[_loc4_].target;
  211.                _loc6_ = !!param2 ? param1[_loc4_].start : param1[_loc4_].end;
  212.                _loc8_ = _loc5_.length;
  213.                _loc9_ = 0;
  214.                while(_loc9_ < _loc8_)
  215.                {
  216.                   _loc6_[_loc5_[_loc9_]] = getValueFromTarget(_loc7_,_loc5_[_loc9_]);
  217.                   _loc9_++;
  218.                }
  219.                _loc4_++;
  220.             }
  221.          }
  222.          var _loc10_:Array;
  223.          if((_loc10_ = !mx_internal::filterObject ? relevantStyles : mergeArrays(relevantStyles,mx_internal::filterObject.filterStyles)) && _loc10_.length > 0)
  224.          {
  225.             _loc3_ = param1.length;
  226.             _loc4_ = 0;
  227.             while(_loc4_ < _loc3_)
  228.             {
  229.                _loc7_ = param1[_loc4_].target;
  230.                _loc6_ = !!param2 ? param1[_loc4_].start : param1[_loc4_].end;
  231.                _loc8_ = _loc10_.length;
  232.                _loc9_ = 0;
  233.                while(_loc9_ < _loc8_)
  234.                {
  235.                   _loc6_[_loc10_[_loc9_]] = _loc7_.getStyle(_loc10_[_loc9_]);
  236.                   _loc9_++;
  237.                }
  238.                _loc4_++;
  239.             }
  240.          }
  241.          return param1;
  242.       }
  243.       
  244.       protected function getValueFromTarget(param1:Object, param2:String) : *
  245.       {
  246.          if(param2 in param1)
  247.          {
  248.             return param1[param2];
  249.          }
  250.          return undefined;
  251.       }
  252.       
  253.       public function set target(param1:Object) : void
  254.       {
  255.          _targets.splice(0);
  256.          if(param1)
  257.          {
  258.             _targets[0] = param1;
  259.          }
  260.       }
  261.       
  262.       public function get className() : String
  263.       {
  264.          var _loc1_:String = getQualifiedClassName(this);
  265.          var _loc2_:int = _loc1_.indexOf("::");
  266.          if(_loc2_ != -1)
  267.          {
  268.             _loc1_ = _loc1_.substr(_loc2_ + 2);
  269.          }
  270.          return _loc1_;
  271.       }
  272.       
  273.       public function set perElementOffset(param1:Number) : void
  274.       {
  275.          _perElementOffset = param1;
  276.       }
  277.       
  278.       public function resume() : void
  279.       {
  280.          var _loc1_:int = 0;
  281.          var _loc2_:int = 0;
  282.          if(isPlaying && isPaused)
  283.          {
  284.             isPaused = false;
  285.             _loc1_ = _instances.length;
  286.             _loc2_ = 0;
  287.             while(_loc2_ < _loc1_)
  288.             {
  289.                IEffectInstance(_instances[_loc2_]).resume();
  290.                _loc2_++;
  291.             }
  292.          }
  293.       }
  294.       
  295.       public function set duration(param1:Number) : void
  296.       {
  297.          durationExplicitlySet = true;
  298.          _duration = param1;
  299.       }
  300.       
  301.       public function play(param1:Array = null, param2:Boolean = false) : Array
  302.       {
  303.          var _loc6_:IEffectInstance = null;
  304.          if(param1 == null && mx_internal::propertyChangesArray != null)
  305.          {
  306.             if(_callValidateNow)
  307.             {
  308.                LayoutManager.getInstance().validateNow();
  309.             }
  310.             if(!endValuesCaptured)
  311.             {
  312.                propertyChangesArray = captureValues(mx_internal::propertyChangesArray,false);
  313.             }
  314.             propertyChangesArray = stripUnchangedValues(mx_internal::propertyChangesArray);
  315.             applyStartValues(mx_internal::propertyChangesArray,this.targets);
  316.          }
  317.          var _loc3_:Array = createInstances(param1);
  318.          var _loc4_:int = _loc3_.length;
  319.          var _loc5_:int = 0;
  320.          while(_loc5_ < _loc4_)
  321.          {
  322.             _loc6_ = IEffectInstance(_loc3_[_loc5_]);
  323.             Object(_loc6_).playReversed = param2;
  324.             _loc6_.startEffect();
  325.             _loc5_++;
  326.          }
  327.          return _loc3_;
  328.       }
  329.       
  330.       public function captureEndValues() : void
  331.       {
  332.          propertyChangesArray = captureValues(mx_internal::propertyChangesArray,false);
  333.          endValuesCaptured = true;
  334.       }
  335.       
  336.       protected function filterInstance(param1:Array, param2:Object) : Boolean
  337.       {
  338.          if(mx_internal::filterObject)
  339.          {
  340.             return mx_internal::filterObject.filterInstance(param1,effectTargetHost,param2);
  341.          }
  342.          return true;
  343.       }
  344.       
  345.       public function get customFilter() : EffectTargetFilter
  346.       {
  347.          return _customFilter;
  348.       }
  349.       
  350.       public function get effectTargetHost() : IEffectTargetHost
  351.       {
  352.          return _effectTargetHost;
  353.       }
  354.       
  355.       public function set relevantProperties(param1:Array) : void
  356.       {
  357.          _relevantProperties = param1;
  358.       }
  359.       
  360.       public function captureMoreStartValues(param1:Array) : void
  361.       {
  362.          var _loc2_:Array = null;
  363.          if(param1.length > 0)
  364.          {
  365.             _loc2_ = captureValues(null,true);
  366.             propertyChangesArray = mx_internal::propertyChangesArray.concat(_loc2_);
  367.          }
  368.       }
  369.       
  370.       public function deleteInstance(param1:IEffectInstance) : void
  371.       {
  372.          EventDispatcher(param1).removeEventListener(EffectEvent.EFFECT_START,effectStartHandler);
  373.          EventDispatcher(param1).removeEventListener(EffectEvent.EFFECT_END,effectEndHandler);
  374.          var _loc2_:int = _instances.length;
  375.          var _loc3_:int = 0;
  376.          while(_loc3_ < _loc2_)
  377.          {
  378.             if(_instances[_loc3_] === param1)
  379.             {
  380.                _instances.splice(_loc3_,1);
  381.             }
  382.             _loc3_++;
  383.          }
  384.       }
  385.       
  386.       public function get filter() : String
  387.       {
  388.          return _filter;
  389.       }
  390.       
  391.       public function set triggerEvent(param1:Event) : void
  392.       {
  393.          _triggerEvent = param1;
  394.       }
  395.       
  396.       public function get target() : Object
  397.       {
  398.          if(_targets.length > 0)
  399.          {
  400.             return _targets[0];
  401.          }
  402.          return null;
  403.       }
  404.       
  405.       public function get duration() : Number
  406.       {
  407.          return _duration;
  408.       }
  409.       
  410.       public function set customFilter(param1:EffectTargetFilter) : void
  411.       {
  412.          _customFilter = param1;
  413.          filterObject = param1;
  414.       }
  415.       
  416.       public function get perElementOffset() : Number
  417.       {
  418.          return _perElementOffset;
  419.       }
  420.       
  421.       public function set effectTargetHost(param1:IEffectTargetHost) : void
  422.       {
  423.          _effectTargetHost = param1;
  424.       }
  425.       
  426.       public function get isPlaying() : Boolean
  427.       {
  428.          return _instances && _instances.length > 0;
  429.       }
  430.       
  431.       protected function effectEndHandler(param1:EffectEvent) : void
  432.       {
  433.          var _loc2_:IEffectInstance = IEffectInstance(param1.effectInstance);
  434.          deleteInstance(_loc2_);
  435.          dispatchEvent(param1);
  436.       }
  437.       
  438.       public function get relevantProperties() : Array
  439.       {
  440.          if(_relevantProperties)
  441.          {
  442.             return _relevantProperties;
  443.          }
  444.          return getAffectedProperties();
  445.       }
  446.       
  447.       public function createInstance(param1:Object = null) : IEffectInstance
  448.       {
  449.          var _loc6_:int = 0;
  450.          var _loc7_:int = 0;
  451.          if(!param1)
  452.          {
  453.             param1 = this.target;
  454.          }
  455.          var _loc2_:IEffectInstance = null;
  456.          var _loc3_:PropertyChanges = null;
  457.          var _loc4_:Boolean = true;
  458.          var _loc5_:Boolean = false;
  459.          if(mx_internal::propertyChangesArray)
  460.          {
  461.             _loc5_ = true;
  462.             _loc4_ = filterInstance(mx_internal::propertyChangesArray,param1);
  463.          }
  464.          if(_loc4_)
  465.          {
  466.             _loc2_ = IEffectInstance(new instanceClass(param1));
  467.             initInstance(_loc2_);
  468.             if(_loc5_)
  469.             {
  470.                _loc6_ = mx_internal::propertyChangesArray.length;
  471.                _loc7_ = 0;
  472.                while(_loc7_ < _loc6_)
  473.                {
  474.                   if(mx_internal::propertyChangesArray[_loc7_].target == param1)
  475.                   {
  476.                      _loc2_.propertyChanges = mx_internal::propertyChangesArray[_loc7_];
  477.                   }
  478.                   _loc7_++;
  479.                }
  480.             }
  481.             EventDispatcher(_loc2_).addEventListener(EffectEvent.EFFECT_START,effectStartHandler);
  482.             EventDispatcher(_loc2_).addEventListener(EffectEvent.EFFECT_END,effectEndHandler);
  483.             _instances.push(_loc2_);
  484.             if(triggerEvent)
  485.             {
  486.                _loc2_.initEffect(triggerEvent);
  487.             }
  488.          }
  489.          return _loc2_;
  490.       }
  491.       
  492.       protected function effectStartHandler(param1:EffectEvent) : void
  493.       {
  494.          dispatchEvent(param1);
  495.       }
  496.       
  497.       public function getAffectedProperties() : Array
  498.       {
  499.          return [];
  500.       }
  501.       
  502.       public function set relevantStyles(param1:Array) : void
  503.       {
  504.          _relevantStyles = param1;
  505.       }
  506.       
  507.       public function get triggerEvent() : Event
  508.       {
  509.          return _triggerEvent;
  510.       }
  511.       
  512.       protected function applyValueToTarget(param1:Object, param2:String, param3:*, param4:Object) : void
  513.       {
  514.          var target:Object = param1;
  515.          var property:String = param2;
  516.          var value:* = param3;
  517.          var props:Object = param4;
  518.          if(property in target)
  519.          {
  520.             try
  521.             {
  522.                if(mx_internal::applyActualDimensions && target is IFlexDisplayObject && property == "height")
  523.                {
  524.                   target.setActualSize(target.width,value);
  525.                }
  526.                else if(mx_internal::applyActualDimensions && target is IFlexDisplayObject && property == "width")
  527.                {
  528.                   target.setActualSize(value,target.height);
  529.                }
  530.                else
  531.                {
  532.                   target[property] = value;
  533.                }
  534.             }
  535.             catch(e:Error)
  536.             {
  537.             }
  538.          }
  539.       }
  540.       
  541.       protected function initInstance(param1:IEffectInstance) : void
  542.       {
  543.          param1.duration = duration;
  544.          Object(param1).durationExplicitlySet = mx_internal::durationExplicitlySet;
  545.          param1.effect = this;
  546.          param1.effectTargetHost = effectTargetHost;
  547.          param1.hideFocusRing = hideFocusRing;
  548.          param1.repeatCount = repeatCount;
  549.          param1.repeatDelay = repeatDelay;
  550.          param1.startDelay = startDelay;
  551.          param1.suspendBackgroundProcessing = suspendBackgroundProcessing;
  552.       }
  553.       
  554.       mx_internal function applyStartValues(param1:Array, param2:Array) : void
  555.       {
  556.          var _loc6_:int = 0;
  557.          var _loc7_:int = 0;
  558.          var _loc8_:Object = null;
  559.          var _loc9_:Boolean = false;
  560.          var _loc3_:Array = relevantProperties;
  561.          var _loc4_:int = param1.length;
  562.          var _loc5_:int = 0;
  563.          while(_loc5_ < _loc4_)
  564.          {
  565.             _loc8_ = param1[_loc5_].target;
  566.             _loc9_ = false;
  567.             _loc6_ = param2.length;
  568.             _loc7_ = 0;
  569.             while(_loc7_ < _loc6_)
  570.             {
  571.                if(param2[_loc7_] == _loc8_)
  572.                {
  573.                   _loc9_ = filterInstance(param1,_loc8_);
  574.                   break;
  575.                }
  576.                _loc7_++;
  577.             }
  578.             if(_loc9_)
  579.             {
  580.                _loc6_ = _loc3_.length;
  581.                _loc7_ = 0;
  582.                while(_loc7_ < _loc6_)
  583.                {
  584.                   if(_loc3_[_loc7_] in param1[_loc5_].start && _loc3_[_loc7_] in _loc8_)
  585.                   {
  586.                      applyValueToTarget(_loc8_,_loc3_[_loc7_],param1[_loc5_].start[_loc3_[_loc7_]],param1[_loc5_].start);
  587.                   }
  588.                   _loc7_++;
  589.                }
  590.                _loc6_ = relevantStyles.length;
  591.                _loc7_ = 0;
  592.                while(_loc7_ < _loc6_)
  593.                {
  594.                   if(relevantStyles[_loc7_] in param1[_loc5_].start)
  595.                   {
  596.                      _loc8_.setStyle(relevantStyles[_loc7_],param1[_loc5_].start[relevantStyles[_loc7_]]);
  597.                   }
  598.                   _loc7_++;
  599.                }
  600.             }
  601.             _loc5_++;
  602.          }
  603.       }
  604.       
  605.       public function end(param1:IEffectInstance = null) : void
  606.       {
  607.          var _loc2_:int = 0;
  608.          var _loc3_:int = 0;
  609.          var _loc4_:IEffectInstance = null;
  610.          if(param1)
  611.          {
  612.             param1.end();
  613.          }
  614.          else
  615.          {
  616.             _loc2_ = _instances.length;
  617.             _loc3_ = _loc2_;
  618.             while(_loc3_ >= 0)
  619.             {
  620.                if(_loc4_ = IEffectInstance(_instances[_loc3_]))
  621.                {
  622.                   _loc4_.end();
  623.                }
  624.                _loc3_--;
  625.             }
  626.          }
  627.       }
  628.       
  629.       public function get relevantStyles() : Array
  630.       {
  631.          return _relevantStyles;
  632.       }
  633.       
  634.       public function createInstances(param1:Array = null) : Array
  635.       {
  636.          var _loc6_:IEffectInstance = null;
  637.          if(!param1)
  638.          {
  639.             param1 = this.targets;
  640.          }
  641.          var _loc2_:Array = [];
  642.          var _loc3_:int = param1.length;
  643.          var _loc4_:Number = 0;
  644.          var _loc5_:int = 0;
  645.          while(_loc5_ < _loc3_)
  646.          {
  647.             if(_loc6_ = createInstance(param1[_loc5_]))
  648.             {
  649.                _loc6_.startDelay += _loc4_;
  650.                _loc4_ += perElementOffset;
  651.                _loc2_.push(_loc6_);
  652.             }
  653.             _loc5_++;
  654.          }
  655.          triggerEvent = null;
  656.          return _loc2_;
  657.       }
  658.       
  659.       public function pause() : void
  660.       {
  661.          var _loc1_:int = 0;
  662.          var _loc2_:int = 0;
  663.          if(isPlaying && !isPaused)
  664.          {
  665.             isPaused = true;
  666.             _loc1_ = _instances.length;
  667.             _loc2_ = 0;
  668.             while(_loc2_ < _loc1_)
  669.             {
  670.                IEffectInstance(_instances[_loc2_]).pause();
  671.                _loc2_++;
  672.             }
  673.          }
  674.       }
  675.       
  676.       public function set filter(param1:String) : void
  677.       {
  678.          if(!customFilter)
  679.          {
  680.             _filter = param1;
  681.             switch(param1)
  682.             {
  683.                case "add":
  684.                case "remove":
  685.                   filterObject = new AddRemoveEffectTargetFilter();
  686.                   AddRemoveEffectTargetFilter(mx_internal::filterObject).add = param1 == "add";
  687.                   break;
  688.                case "hide":
  689.                case "show":
  690.                   filterObject = new HideShowEffectTargetFilter();
  691.                   HideShowEffectTargetFilter(mx_internal::filterObject).show = param1 == "show";
  692.                   break;
  693.                case "move":
  694.                   filterObject = new EffectTargetFilter();
  695.                   mx_internal::filterObject.filterProperties = ["x","y"];
  696.                   break;
  697.                case "resize":
  698.                   filterObject = new EffectTargetFilter();
  699.                   mx_internal::filterObject.filterProperties = ["width","height"];
  700.                   break;
  701.                case "addItem":
  702.                   filterObject = new EffectTargetFilter();
  703.                   mx_internal::filterObject.requiredSemantics = {"added":true};
  704.                   break;
  705.                case "removeItem":
  706.                   filterObject = new EffectTargetFilter();
  707.                   mx_internal::filterObject.requiredSemantics = {"removed":true};
  708.                   break;
  709.                case "replacedItem":
  710.                   filterObject = new EffectTargetFilter();
  711.                   mx_internal::filterObject.requiredSemantics = {"replaced":true};
  712.                   break;
  713.                case "replacementItem":
  714.                   filterObject = new EffectTargetFilter();
  715.                   mx_internal::filterObject.requiredSemantics = {"replacement":true};
  716.                   break;
  717.                default:
  718.                   filterObject = null;
  719.             }
  720.          }
  721.       }
  722.       
  723.       public function reverse() : void
  724.       {
  725.          var _loc1_:int = 0;
  726.          var _loc2_:int = 0;
  727.          if(isPlaying)
  728.          {
  729.             _loc1_ = _instances.length;
  730.             _loc2_ = 0;
  731.             while(_loc2_ < _loc1_)
  732.             {
  733.                IEffectInstance(_instances[_loc2_]).reverse();
  734.                _loc2_++;
  735.             }
  736.          }
  737.       }
  738.    }
  739. }
  740.